Patterns de Conception Python : Plongée en Profondeur dans les Patterns Créationnels

            
class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

# Exemple d'utilisation
s1 = Singleton()
s2 = Singleton()

print(s1 is s2) # Output: True

            

              
                Copy
              
            
          

            
class ConfigurationManager(Singleton):
    def __init__(self):
        if not hasattr(self, 'config'): # S'assurer que __init__ n'est appelé qu'une fois
            self.config = {}

    def set_config(self, key, value):
        self.config[key] = value

    def get_config(self, key):
        return self.config.get(key)

# Exemple d'utilisation
config_manager1 = ConfigurationManager()
config_manager1.set_config('database_url', 'localhost:5432')

config_manager2 = ConfigurationManager()
print(config_manager2.get_config('database_url')) # Output: localhost:5432

            

              
                Copy
              
            
          

            
from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class AnimalFactory(ABC):
    @abstractmethod
    def create_animal(self):
        pass

class DogFactory(AnimalFactory):
    def create_animal(self):
        return Dog()

class CatFactory(AnimalFactory):
    def create_animal(self):
        return Cat()

# Code client
def get_animal(factory: AnimalFactory):
    animal = factory.create_animal()
    return animal.speak()


dog_sound = get_animal(DogFactory())
cat_sound = get_animal(CatFactory())

print(f"Dog says: {dog_sound}") # Output: Dog says: Woof!
print(f"Cat says: {cat_sound}") # Output: Cat says: Meow!

            

              
                Copy
              
            
          

            
from abc import ABC, abstractmethod

class Payment(ABC):
    @abstractmethod
    def process_payment(self, amount):
        pass

class CreditCardPayment(Payment):
    def process_payment(self, amount):
        return f"Processing credit card payment of ${amount}"

class PayPalPayment(Payment):
    def process_payment(self, amount):
        return f"Processing PayPal payment of ${amount}"

class PaymentFactory(ABC):
    @abstractmethod
    def create_payment_method(self):
        pass

class CreditCardPaymentFactory(PaymentFactory):
    def create_payment_method(self):
        return CreditCardPayment()

class PayPalPaymentFactory(PaymentFactory):
    def create_payment_method(self):
        return PayPalPayment()

# Code client
def process_payment(factory: PaymentFactory, amount):
    payment_method = factory.create_payment_method()
    return payment_method.process_payment(amount)


credit_card_payment = process_payment(CreditCardPaymentFactory(), 100)
paypal_payment = process_payment(PayPalPaymentFactory(), 50)

print(credit_card_payment) # Output: Processing credit card payment of $100
print(paypal_payment) # Output: Processing PayPal payment of $50

            

              
                Copy
              
            
          

            
from abc import ABC, abstractmethod

class Button(ABC):
    @abstractmethod
    def paint(self):
        pass

class Checkbox(ABC):
    @abstractmethod
    def paint(self):
        pass

class GUIFactory(ABC):
    @abstractmethod
    def create_button(self):
        pass

    @abstractmethod
    def create_checkbox(self):
        pass

class WinFactory(GUIFactory):
    def create_button(self):
        return WinButton()

    def create_checkbox(self):
        return WinCheckbox()

class MacFactory(GUIFactory):
    def create_button(self):
        return MacButton()

    def create_checkbox(self):
        return MacCheckbox()

class WinButton(Button):
    def paint(self):
        return "Rendering a Windows button"

class MacButton(Button):
    def paint(self):
        return "Rendering a Mac button"

class WinCheckbox(Checkbox):
    def paint(self):
        return "Rendering a Windows checkbox"

class MacCheckbox(Checkbox):
    def paint(self):
        return "Rendering a Mac checkbox"

# Code client
def paint_ui(factory: GUIFactory):
    button = factory.create_button()
    checkbox = factory.create_checkbox()
    return button.paint(), checkbox.paint()

win_button, win_checkbox = paint_ui(WinFactory())
mac_button, mac_checkbox = paint_ui(MacFactory())

print(win_button) # Output: Rendering a Windows button
print(win_checkbox) # Output: Rendering a Windows checkbox
print(mac_button) # Output: Rendering a Mac button
print(mac_checkbox) # Output: Rendering a Mac checkbox

            

              
                Copy
              
            
          

            
from abc import ABC, abstractmethod

class Chair(ABC):
    @abstractmethod
    def create(self):
        pass

class Table(ABC):
    @abstractmethod
    def create(self):
        pass

class FurnitureFactory(ABC):
    @abstractmethod
    def create_chair(self):
        pass

    @abstractmethod
    def create_table(self):
        pass

class ModernFurnitureFactory(FurnitureFactory):
    def create_chair(self):
        return ModernChair()

    def create_table(self):
        return ModernTable()

class VictorianFurnitureFactory(FurnitureFactory):
    def create_chair(self):
        return VictorianChair()

    def create_table(self):
        return VictorianTable()

class ModernChair(Chair):
    def create(self):
        return "Creating a modern chair"

class VictorianChair(Chair):
    def create(self):
        return "Creating a Victorian chair"

class ModernTable(Table):
    def create(self):
        return "Creating a modern table"

class VictorianTable(Table):
    def create(self):
        return "Creating a Victorian table"

# Code client
def create_furniture(factory: FurnitureFactory):
    chair = factory.create_chair()
    table = factory.create_table()
    return chair.create(), table.create()


modern_chair, modern_table = create_furniture(ModernFurnitureFactory())
victorian_chair, victorian_table = create_furniture(VictorianFurnitureFactory())

print(modern_chair) # Output: Creating a modern chair
print(modern_table) # Output: Creating a modern table
print(victorian_chair) # Output: Creating a Victorian chair
print(victorian_table) # Output: Creating a Victorian table

            

              
                Copy
              
            
          

            
class Pizza:
    def __init__(self):
        self.dough = None
        self.sauce = None
        self.topping = None

    def __str__(self):
        return f"Pizza with dough: {self.dough}, sauce: {self.sauce}, and topping: {self.topping}"

class PizzaBuilder:
    def __init__(self):
        self.pizza = Pizza()

    def set_dough(self, dough):
        self.pizza.dough = dough
        return self

    def set_sauce(self, sauce):
        self.pizza.sauce = sauce
        return self

    def set_topping(self, topping):
        self.pizza.topping = topping
        return self

    def build(self):
        return self.pizza

# Code client
pizza_builder = PizzaBuilder()
pizza = pizza_builder.set_dough("Thin crust").set_sauce("Tomato").set_topping("Pepperoni").build()

print(pizza) # Output: Pizza with dough: Thin crust, sauce: Tomato, and topping: Pepperoni

            

              
                Copy
              
            
          

            
class Computer:
    def __init__(self):
        self.cpu = None
        self.ram = None
        self.storage = None
        self.graphics_card = None

    def __str__(self):
        return f"Computer with CPU: {self.cpu}, RAM: {self.ram}, Storage: {self.storage}, Graphics Card: {self.graphics_card}"

class ComputerBuilder:
    def __init__(self):
        self.computer = Computer()

    def set_cpu(self, cpu):
        self.computer.cpu = cpu
        return self

    def set_ram(self, ram):
        self.computer.ram = ram
        return self

    def set_storage(self, storage):
        self.computer.storage = storage
        return self

    def set_graphics_card(self, graphics_card):
        self.computer.graphics_card = graphics_card
        return self

    def build(self):
        return self.computer

# Code client
computer_builder = ComputerBuilder()
computer = computer_builder.set_cpu("Intel i7").set_ram("16GB").set_storage("1TB SSD").set_graphics_card("Nvidia RTX 3080").build()

print(computer)
# Output: Computer with CPU: Intel i7, RAM: 16GB, Storage: 1TB SSD, Graphics Card: Nvidia RTX 3080

            

              
                Copy
              
            
          

            
import copy

class Prototype:
    def __init__(self):
        self._objects = {}

    def register_object(self, name, obj):
        self._objects[name] = obj

    def unregister_object(self, name):
        del self._objects[name]

    def clone(self, name, **attrs):
        obj = copy.deepcopy(self._objects.get(name))
        if attrs:
            obj.__dict__.update(attrs)
        return obj

class Car:
    def __init__(self):
        self.name = ""
        self.color = ""
        self.options = []

    def __str__(self):
        return f"Car: Name={self.name}, Color={self.color}, Options={self.options}"

# Code client
prototype = Prototype()
car = Car()
car.name = "Generic Car"
car.color = "White"
car.options = ["AC", "GPS"]

prototype.register_object("generic", car)

car1 = prototype.clone("generic", name="Sports Car", color="Red", options=["AC", "GPS", "Spoiler"])
car2 = prototype.clone("generic", name="Family Car", color="Blue", options=["AC", "GPS", "Sunroof"])

print(car1)
# Output: Car: Name=Sports Car, Color=Red, Options=['AC', 'GPS', 'Spoiler']
print(car2)
# Output: Car: Name=Family Car, Color=Blue, Options=['AC', 'GPS', 'Sunroof']

            

              
                Copy
              
            
          

            
import copy

class Employee:
    def __init__(self):
        self.name = None
        self.role = None
        self.department = None

    def __str__(self):
        return f"Employee: Name={self.name}, Role={self.role}, Department={self.department}"

class Prototype:
    def __init__(self):
        self._objects = {}

    def register_object(self, name, obj):
        self._objects[name] = obj

    def unregister_object(self, name):
        del self._objects[name]

    def clone(self, name, **attrs):
        obj = copy.deepcopy(self._objects.get(name))
        if attrs:
            obj.__dict__.update(attrs)
        return obj


# Code client
prototype = Prototype()
employee = Employee()
employee.name = "Generic Employee"
employee.role = "Developer"
employee.department = "IT"

prototype.register_object("generic", employee)

employee1 = prototype.clone("generic", name="John Doe", role="Senior Developer")
employee2 = prototype.clone("generic", name="Jane Smith", role="Project Manager", department="Management")

print(employee1)
# Output: Employee: Name=John Doe, Role=Senior Developer, Department=IT
print(employee2)
# Output: Employee: Name=Jane Smith, Role=Project Manager, Department=Management

            

              
                Copy